package models

import (
	"database/sql"
	"fmt"
	"log"
	"math/rand"
	"time"
)

func init() {
	// 初始化随机数生成器
	rand.Seed(time.Now().UnixNano())
}

// User 结构体表示用户，包含用户名、邮箱、密码、电话等字段
type User struct {
	ID          int    `json:"id"`          // 用户ID
	Username    string `json:"username"`    // 用户名
	Password    string `json:"password"`    // 密码
	Phonenumber string `json:"phonenumber"` // 手机号
	Email       string `json:"email"`       // 邮箱
}

// 根据用户ID获取用户信息
func GetUserByID(id int) (User, error) {
	var user User
	err := db.QueryRow("SELECT id, username, password, phonenumber, email FROM users WHERE id = ?", id).
		Scan(&user.ID, &user.Username, &user.Password, &user.Phonenumber, &user.Email)
	if err != nil {
		if err == sql.ErrNoRows {
			return user, fmt.Errorf("用户不存在")
		}
		return user, err
	}
	return user, nil
}

// 根据用户名获取用户信息
func GetUserByUsername(username string) (User, error) {
	var user User
	err := db.QueryRow("SELECT id, username, password, phonenumber, email FROM users WHERE username = ?", username).
		Scan(&user.ID, &user.Username, &user.Password, &user.Phonenumber, &user.Email)
	if err != nil {
		if err == sql.ErrNoRows {
			// 如果没有找到用户，返回一个空的用户结构体
			return user, nil
		}
		return user, err
	}
	return user, nil
}

// 根据手机号获取用户信息
func GetUserByPhonenumber(phonenumber string) (User, error) {
	var user User
	err := db.QueryRow("SELECT id, username, password, phonenumber, email FROM users WHERE phonenumber = ?", phonenumber).
		Scan(&user.ID, &user.Username, &user.Password, &user.Phonenumber, &user.Email)
	if err != nil {
		if err == sql.ErrNoRows {
			// 如果没有找到用户，返回一个空的用户结构体
			return user, nil
		}
		return user, err
	}
	return user, nil
}

// 根据邮箱获取用户信息
func GetUserByEmail(email string) (User, error) {
	var user User
	err := db.QueryRow("SELECT id, username, password, phonenumber, email FROM users WHERE email = ?", email).
		Scan(&user.ID, &user.Username, &user.Password, &user.Phonenumber, &user.Email)
	if err != nil {
		if err == sql.ErrNoRows {
			// 如果没有找到用户，返回一个空的用户结构体
			return user, nil
		}
		return user, err
	}
	return user, nil
}

// 检查用户名是否已存在
func IsUsernameExist(username string) (bool, error) {
	var user User
	err := db.QueryRow("SELECT id FROM users WHERE username = ?", username).Scan(&user.ID)
	if err != nil {
		if err == sql.ErrNoRows {
			return false, nil // 用户名不存在
		}
		return false, err
	}
	return true, nil // 用户名已存在
}

// 检查邮箱是否已存在
func IsEmailExist(email string) (bool, error) {
	var user User
	err := db.QueryRow("SELECT id FROM users WHERE email = ?", email).Scan(&user.ID)
	if err != nil {
		if err == sql.ErrNoRows {
			return false, nil // 邮箱不存在
		}
		return false, err
	}
	return true, nil // 邮箱已存在
}

// 向用户表添加新用户，首先检查是否存在重复的用户名或邮箱
func AddUser(u User) (int64, error) {
	// 检查用户名是否已存在
	exists, err := IsUsernameExist(u.Username)
	if err != nil {
		log.Println("Error checking username:", err)
		return 0, err
	}
	if exists {
		return 0, fmt.Errorf("用户名已存在")
	}

	// 检查邮箱是否已存在
	exists, err = IsEmailExist(u.Email)
	if err != nil {
		log.Println("Error checking email:", err)
		return 0, err
	}
	if exists {
		return 0, fmt.Errorf("邮箱已存在")
	}

	// 如果没有重复，执行插入操作
	stmt, err := db.Prepare("INSERT INTO users(username, password, phonenumber, email) VALUES(?, ?, ?, ?)")
	if err != nil {
		log.Println("Error preparing statement for AddUser:", err)
		return 0, err
	}
	defer stmt.Close()

	result, err := stmt.Exec(u.Username, u.Password, u.Phonenumber, u.Email)
	if err != nil {
		log.Println("Error executing AddUser:", err)
		return 0, err
	}

	lastInsertID, err := result.LastInsertId()
	if err != nil {
		log.Println("Error getting last insert ID:", err)
		return 0, err
	}

	return lastInsertID, nil
}

// 删除用户及相关数据
func DeleteUser(id int) (int64, error) {
	// 首先检查用户是否存在
	_, err := GetUserByID(id)
	if err != nil {
		return 0, err
	}

	// 开始删除用户
	stmt, err := db.Prepare("DELETE FROM users WHERE id = ?")
	if err != nil {
		log.Println("Error preparing statement for DeleteUser:", err)
		return 0, err
	}
	defer stmt.Close()

	result, err := stmt.Exec(id)
	if err != nil {
		log.Println("Error executing DeleteUser:", err)
		return 0, err
	}

	rowsAffected, err := result.RowsAffected()
	if err != nil {
		log.Println("Error getting rows affected for DeleteUser:", err)
		return 0, err
	}

	log.Printf("Deleted user with ID %d, affected %d rows", id, rowsAffected)
	return rowsAffected, nil
}

// 登录验证，user可'账号名/手机号/邮箱'三选一
func AuthenticateUser(username, password string) (*User, error) {
	var user User
	// 查询数据库时，将每个字段纳入OR查询，以检测用户名、手机号或邮箱
	query := `
        SELECT id, username, password, phonenumber, email
        FROM users
        WHERE username = ? OR phonenumber = ? OR email = ?
        LIMIT 1` // 使用LIMIT限制只返回第一条数据
	err := db.QueryRow(query, username, username, username).
		Scan(&user.ID, &user.Username, &user.Password, &user.Phonenumber, &user.Email)
	if err != nil {
		if err == sql.ErrNoRows {
			return nil, fmt.Errorf("用户不存在")
		}
		return nil, err
	}

	// 验证密码
	if user.Password != password {
		return nil, fmt.Errorf("密码错误")
	}

	return &user, nil
}

// UpdateUser 更新用户信息
func UpdateUser(id int, user User) (*User, error) {
	// 检查用户是否存在
	existingUser, err := GetUserByID(id)
	if err != nil {
		return nil, err
	}
	if existingUser.ID == 0 {
		return nil, fmt.Errorf("用户不存在")
	}

	// 检查用户名是否已被其他用户使用
	if user.Username != existingUser.Username {
		otherUser, _ := GetUserByUsername(user.Username)
		if otherUser.ID != 0 && otherUser.ID != id {
			return nil, fmt.Errorf("用户名已被使用")
		}
	}

	// 检查邮箱是否已被其他用户使用
	if user.Email != existingUser.Email {
		otherUser, _ := GetUserByEmail(user.Email)
		if otherUser.ID != 0 && otherUser.ID != id {
			return nil, fmt.Errorf("邮箱已被使用")
		}
	}

	// 检查手机号是否已被其他用户使用
	if user.Phonenumber != existingUser.Phonenumber {
		otherUser, _ := GetUserByPhonenumber(user.Phonenumber)
		if otherUser.ID != 0 && otherUser.ID != id {
			return nil, fmt.Errorf("手机号已被使用")
		}
	}

	// 如果密码字段为空，使用原有密码
	if user.Password == "" {
		user.Password = existingUser.Password
	}

	// 执行更新
	_, err = db.Exec(`
        UPDATE users 
        SET username = ?, email = ?, phonenumber = ?, password = ? 
        WHERE id = ?`,
		user.Username, user.Email, user.Phonenumber, user.Password, id)
	if err != nil {
		return nil, fmt.Errorf("更新用户信息失败: %v", err)
	}

	// 返回更新后的用户信息
	return &user, nil
}

// CheckUserExists 检查用户是否存在
func CheckUserExists(admin string) (bool, error) {
	var count int
	log.Printf("Checking user existence for: %s", admin)
	err := db.QueryRow(`
        SELECT COUNT(*) 
        FROM users 
        WHERE email = ? OR phonenumber = ?`,
		admin, admin).Scan(&count)

	if err != nil {
		log.Printf("Error checking user existence: %v", err)
		return false, fmt.Errorf("检查用户存在失败: %v", err)
	}

	log.Printf("User exists: %v", count > 0)
	return count > 0, nil
}

// GenerateVerifyCode 生成并保存验证码
func GenerateVerifyCode(admin string) (string, error) {
	// 生成6位随机验证码
	code := fmt.Sprintf("%06d", rand.Intn(1000000))

	result, err := db.Exec(`
        UPDATE users 
        SET verify_code = ? 
        WHERE email = ? OR phonenumber = ?`,
		code, admin, admin)

	if err != nil {
		return "", fmt.Errorf("保存验证码失败: %v", err)
	}

	rows, err := result.RowsAffected()
	if err != nil {
		return "", fmt.Errorf("获取影响行数失败: %v", err)
	}

	if rows == 0 {
		return "", fmt.Errorf("用户不存在")
	}

	return code, nil
}

// VerifyCode 验证验证码
func VerifyCode(admin, code string) error {
	var storedCode string
	err := db.QueryRow(`
        SELECT verify_code 
        FROM users 
        WHERE email = ? OR phonenumber = ?`,
		admin, admin).Scan(&storedCode)

	if err != nil {
		return err
	}

	if code != storedCode {
		return fmt.Errorf("验证码错误")
	}

	return nil
}

// ResetUserPassword 重置用户密码
func ResetUserPassword(admin, newPassword string) error {
	result, err := db.Exec(`
        UPDATE users 
        SET password = ? 
        WHERE email = ? OR phonenumber = ?`,
		newPassword, admin, admin)

	if err != nil {
		return err
	}

	rows, err := result.RowsAffected()
	if err != nil {
		return err
	}

	if rows == 0 {
		return fmt.Errorf("用户不存在")
	}

	return nil
}
